package transfer

import (
	"context"
	"data-transfer/global"
	"data-transfer/plugins"
	"go.uber.org/zap"
)

func InitTestData(s plugins.SourceStore, t plugins.TargetStore) error {
	c := context.Background()
	datas, err := s.GetAllTestData()
	if err != nil {
		global.LOG.Fatal("初始化测试数据失败！", zap.Any("err", err))
		return err
	}
	if len(datas) > 0 {
		nums, e := t.InsertTest(c, datas)
		if e != nil {
			global.LOG.Fatal("插入测试数据失败！", zap.Any("err", e))
			return e
		}
		global.LOG.Info("新增测试数据条数:", zap.Int64("nums", nums))
	}

	return nil
}

// InitInfo 初始化资料
func InitInfo(s plugins.SourceStore, t plugins.TargetStore) error {
	c := context.Background()

	//1.取得股票基本信息
	basicInfos, err := s.GetAllTqSkBasicInfo(c)
	if err != nil {
		global.LOG.Fatal("初始化财务数据-获取股票基本信息失败！", zap.Any("err", err))
		return err
	} else {
		global.LOG.Info("获取股票基本信息数据量：", zap.Int("nums", len(basicInfos)))
	}

	//2.取得大事提醒
	importEvents, err := s.GetAllEventRemind(c, basicInfos)
	if err != nil {
		global.LOG.Fatal("初始化大事提醒失败！", zap.Any("err", err))
		return err
	} else {
		global.LOG.Info("获取大事提醒数据量：", zap.Int("nums", len(importEvents)))
	}

	erc, err := t.DeleteBizData("EVENT_REMIND")
	if err != nil {
		global.LOG.Info("清理表【EVENT_REMIND】数据条数：", zap.Int64("delNums", erc))
	}
	//3.插入大事提醒
	if len(importEvents) > 0 {
		eventNums, e := t.InsertEventRemind(c, importEvents)
		if e != nil {
			global.LOG.Fatal("插入大事提醒数据失败！", zap.Any("err", e))
			return e
		}
		global.LOG.Info("新增大事提醒数据条数:", zap.Int64("nums", eventNums))
	}

	//4.取得分红配送
	dividends, err := s.GetAllDividend(c, basicInfos)
	if err != nil {
		global.LOG.Fatal("初始化分红配送失败！", zap.Any("err", err))
		return err
	} else {
		global.LOG.Info("获取分红配送数据量：", zap.Int("nums", len(dividends)))
	}

	//printDividend(dividends)

	dc, err := t.DeleteBizData("DIVIDEND")
	if err != nil {
		global.LOG.Info("清理表【DIVIDEND】数据条数：", zap.Int64("delNums", dc))
	}

	//5.新增分红派送数据
	if len(dividends) > 0 {
		dividendNums, e := t.InsertDividend(c, dividends)
		if e != nil {
			global.LOG.Fatal("插入分红派送数据失败！", zap.Any("err", e))
			return e
		}
		global.LOG.Info("新增分红派送数据条数:", zap.Int64("nums", dividendNums))
	}

	//6. 取得融资融券
	margins, err := s.GetAllMargin(c, basicInfos)
	if err != nil {
		global.LOG.Fatal("初始化融资融券失败！", zap.Any("err", err))
		return err
	} else {
		global.LOG.Info("获取融资融券数据量：", zap.Int("nums", len(margins)))
	}

	//printMargins(margins)

	mc, err := t.DeleteBizData("MARGIN")
	if err != nil {
		global.LOG.Info("清理表【MARGIN】数据条数：", zap.Int64("delNums", mc))
	}
	//7.插入融资融券
	if len(margins) > 0 {
		marginNums, e := t.InsertMargin(c, margins)
		if e != nil {
			global.LOG.Fatal("插入融资融券失败！", zap.Any("err", e))
			return e
		}
		global.LOG.Info("新增融资融券数据条数:", zap.Int64("nums", marginNums))
	}

	//8. 取得盈利预测
	//profitForcasts, err := s.GetAllProfitForecast(c, basicInfos)
	profitForcasts, err := s.GetAllProfitForecastNew(c, basicInfos)
	if err != nil {
		global.LOG.Fatal("初始化盈利预测失败！", zap.Any("err", err))
		return err
	} else {
		global.LOG.Info("获取盈利预测数据量：", zap.Int("nums", len(profitForcasts)))
	}

	//printProfitForcast(profitForcasts)

	pfc, err := t.DeleteBizData("PROFIT_FORECAST")
	if err != nil {
		global.LOG.Info("清理表【PROFIT_FORECAST】数据条数：", zap.Int64("delNums", pfc))
	}

	//9.插入盈利预测数据
	if len(profitForcasts) > 0 {
		pfNums, e := t.InsertProfitForecast(c, profitForcasts)
		if e != nil {
			global.LOG.Fatal("插入盈利预测失败！", zap.Any("err", e))
			return e
		}
		global.LOG.Info("新增盈利预测条数:", zap.Int64("nums", pfNums))
	}

	//10. 获取股本结构变化
	equityStrus, err := s.GetAllEquityStructure(c, basicInfos)
	if err != nil {
		global.LOG.Fatal("初始化股本结构变化信息失败！", zap.Any("err", err))
		return err
	} else {
		global.LOG.Info("获取股本结构变化数据量：", zap.Int("nums", len(equityStrus)))
	}
	//printEquityStructure(equityStrus)

	esc, err := t.DeleteBizData("EQUITY_STRUCTURE")
	if err != nil {
		global.LOG.Info("清理表【EQUITY_STRUCTURE】数据条数：", zap.Int64("delNums", esc))
	}

	// 11.插入股本结构变化
	if len(equityStrus) > 0 {
		esNums, e := t.InsertEquityStructure(c, equityStrus)
		if e != nil {
			global.LOG.Fatal("插入股本结构信息失败！", zap.Any("err", e))
			return e
		}
		global.LOG.Info("新增股本结构信息数据条数:", zap.Int64("nums", esNums))
	}

	//12. 获取股本变动数据
	equityStruChgs, err := s.GetAllEquityStruChg(c, basicInfos)
	if err != nil {
		global.LOG.Fatal("初始化股本变动信息失败！", zap.Any("err", err))
		return err
	} else {
		global.LOG.Info("获取股本变动数据量：", zap.Int("nums", len(equityStruChgs)))
	}

	//printEquityStruChgs(equityStruChgs)

	escc, err := t.DeleteBizData("EQUITY_STRUCTURE_CHANGE")
	if err != nil {
		global.LOG.Info("清理表【EQUITY_STRUCTURE_CHANGE】数据条数：", zap.Int64("delNums", escc))
	}

	//13.插入股本变动数据
	if len(equityStruChgs) > 0 {
		eschgs, e := t.InsertEquityStruChg(c, equityStruChgs)
		if e != nil {
			global.LOG.Fatal("插入股本变动信息失败！", zap.Any("err", e))
			return e
		}
		global.LOG.Info("新增股本变动信息数据条数:", zap.Int64("nums", eschgs))
	}

	//14. 获取十大流通股股东
	sharesHolders, err := s.GetAllTenCirculatingSharesHolder(c, basicInfos)
	if err != nil {
		global.LOG.Fatal("初始化十大流通股股东失败！", zap.Any("err", err))
		return err
	} else {
		global.LOG.Info("获取十大流通股东数据量：", zap.Int("nums", len(sharesHolders)))
	}

	//printTenCirculatingSharesHolder(sharesHolders)

	tcshc, err := t.DeleteBizData("TEN_CIRCULATING_SHARES_HOLDER")
	if err != nil {
		global.LOG.Info("清理表【TEN_CIRCULATING_SHARES_HOLDER】数据条数：", zap.Int64("delNums", tcshc))
	}

	//15. 插入十大流通股股东
	if len(sharesHolders) > 0 {
		shNums, e := t.InsertTenCirculatingSharesHolder(c, sharesHolders)
		if e != nil {
			global.LOG.Fatal("插入十大流通股股东失败！", zap.Any("err", e))
			return e
		}
		global.LOG.Info("新增十大流通股股东数据条数:", zap.Int64("nums", shNums))
	}

	//16.获取分红融资
	bonusFinancings, err := s.GetAllBonusFinancing(c, basicInfos)
	if err != nil {
		global.LOG.Fatal("初始化分红融资失败！", zap.Any("err", err))
		return err
	} else {
		global.LOG.Info("获取分红融资数据量：", zap.Int("nums", len(bonusFinancings)))
	}

	//printBonusFinancing(bonusFinancings)

	bfc, err := t.DeleteBizData("BONUS_FINANCING")
	if err != nil {
		global.LOG.Info("清理表【BONUS_FINANCING】数据条数：", zap.Int64("delNums", bfc))
	}

	//17.插入分红融资
	if len(bonusFinancings) > 0 {
		bfNums, e := t.InsertBonusFinancing(c, bonusFinancings)
		if e != nil {
			global.LOG.Fatal("插入分红融资失败！", zap.Any("err", e))
			return e
		}
		global.LOG.Info("新增分红融资数据条数:", zap.Int64("nums", bfNums))
	}

	//18.获取所有龙虎榜数据
	rankList, err := s.GetAllRankList(c, basicInfos)
	if err != nil {
		global.LOG.Fatal("初始化龙虎榜失败！", zap.Any("err", err))
		return err
	} else {
		global.LOG.Info("获取龙虎榜数据量：", zap.Int("nums", len(rankList)))
	}

	//printRankList(rankList)

	rlc, err := t.DeleteBizData("RANK_LIST")
	if err != nil {
		global.LOG.Info("清理表【RANK_LIST】数据条数：", zap.Int64("delNums", rlc))
	}

	//19.插入龙虎榜数据
	if len(rankList) > 0 {
		rlNums, e := t.InsertRankList(c, rankList)
		if e != nil {
			global.LOG.Fatal("插入龙虎榜失败！", zap.Any("err", e))
			return e
		}
		global.LOG.Info("新增龙虎榜数据条数:", zap.Int64("nums", rlNums))
	}

	//20.获取大宗交易
	blockTradings, err := s.GetAllBlockTrading(c, basicInfos)
	if err != nil {
		global.LOG.Fatal("初始化大宗交易失败%v:", zap.Any("err", err))
		return err
	} else {
		global.LOG.Info("获取大宗交易数据量：", zap.Int("nums", len(blockTradings)))
	}
	//printBlockTrading(blockTradings)

	btc, err := t.DeleteBizData("BLOCK_TRADING")
	if err != nil {
		global.LOG.Info("清理表【BLOCK_TRADING】数据条数：", zap.Int64("delNums", btc))
	}

	//21.插入大宗交易
	if len(blockTradings) > 0 {
		btNums, e := t.InsertBlockTrading(c, blockTradings)
		if e != nil {
			global.LOG.Fatal("插入大宗交易失败！", zap.Any("err", e))
			return err
		}
		global.LOG.Info("新增大宗交易数据条数:", zap.Int64("nums", btNums))
	}

	//22. 取得公司高管信息
	companyExecutives, err := s.GetALlCompanyExecutives(c, basicInfos)
	if err != nil {
		global.LOG.Fatal("初始化公司高管信息失败！", zap.Any("err", err))
		return err
	} else {
		global.LOG.Info("获取公司高管数据量：", zap.Int("nums", len(companyExecutives)))
	}

	//printExecutive(companyExecutives)

	cec, err := t.DeleteBizData("COMPANY_EXECUTIVES")
	if err != nil {
		global.LOG.Info("清理表【COMPANY_EXECUTIVES】数据条数：", zap.Int64("delNums", cec))
	}

	//23. 插入公司高管数据
	if len(companyExecutives) > 0 {
		ceNums, e := t.InsertCompanyExecutives(c, companyExecutives)
		if e != nil {
			global.LOG.Fatal("插入公司高管信息失败！", zap.Any("err", e))
			return err
		}
		global.LOG.Info("新增公司高管数据条数:", zap.Int64("nums", ceNums))
	}

	//24. 取得公司所有主要业务
	mainComposition, err := s.GetAllMainComposition(c, basicInfos)
	if err != nil {
		global.LOG.Fatal("初始化公司主要业务数据失败！", zap.Any("err", err))
		return err
	} else {
		global.LOG.Info("获取公司主要业务数据量：", zap.Int("nums", len(mainComposition)))
	}

	//printMainComposition(mainComposition)

	mcc, err := t.DeleteBizData("MAIN_COMPOSITION")
	if err != nil {
		global.LOG.Info("清理表【MAIN_COMPOSITION】数据条数：", zap.Int64("delNums", mcc))
	}

	//25.插入公司主要业务数据
	if len(mainComposition) > 0 {
		mcNums, e := t.InsertMainComposition(c, mainComposition)
		if e != nil {
			global.LOG.Fatal("插入公司主要业务数据失败！", zap.Any("err", e))
			return e
		}
		global.LOG.Info("新增公司主要业务数据条数:", zap.Int64("nums", mcNums))
	}

	//26. 获取公司基本情况
	compayProfiles, err := s.GetAllCompanyProfile(c, basicInfos)
	if err != nil {
		global.LOG.Fatal("初始化公司基本情况数据失败！", zap.Any("err", err))
		return err
	} else {
		global.LOG.Info("获取公司基本情况数据量：", zap.Int("nums", len(compayProfiles)))
	}

	//printCompanyProfiles(compayProfiles)

	cpc, err := t.DeleteBizData("COMPANY_PROFILE")
	if err != nil {
		global.LOG.Info("清理表【COMPANY_PROFILE】数据条数：", zap.Int64("delNums", cpc))
	}

	//27. 插入公司基本情况
	if len(compayProfiles) > 0 {
		cpNums, e := t.InsertCompanyProfile(c, compayProfiles)
		if e != nil {
			global.LOG.Fatal("插入公司基本情况数据失败！", zap.Any("err", e))
			return e
		}
		global.LOG.Info("新增公司基本情况数据条数:", zap.Int64("nums", cpNums))
	}

	//28.取得所有股东变动数据
	holderChanges, err := s.GetAllHolderChange(c, basicInfos)
	if err != nil {
		global.LOG.Fatal("初始化股东变动数据失败！", zap.Any("err", err))
		return err
	} else {
		global.LOG.Info("获取股东变动情况数据量：", zap.Int("nums", len(holderChanges)))
	}

	//printHolderChange(holderChanges)

	hcc, err := t.DeleteBizData("HOLDER_CHANGE")
	if err != nil {
		global.LOG.Info("清理表【HOLDER_CHANGE】数据条数：", zap.Int64("delNums", hcc))
	}

	// 29.插入股东变动数据
	if len(holderChanges) > 0 {
		hcNums, e := t.InsertHolderChange(c, holderChanges)
		if e != nil {
			global.LOG.Fatal("插入股东变动情况数据失败！", zap.Any("err", e))
			return e
		}
		global.LOG.Info("新增股东变动情况数据条数:", zap.Int64("nums", hcNums))
	}

	//30.获取十大股东信息
	tenHolders, err := s.GetAllTenHolder(c, basicInfos)
	if err != nil {
		global.LOG.Fatal("初始化十大股东数据失败:", zap.Any("err", err))
		return err
	} else {
		global.LOG.Info("获取十大股东数据量：", zap.Int("nums", len(tenHolders)))
	}

	//printTenHolder(tenHolders)

	thc, err := t.DeleteBizData("TEN_HOLDER")
	if err != nil {
		global.LOG.Info("清理表【TEN_HOLDER】数据条数：", zap.Int64("delNums", thc))
	}

	//31.插入十大股东信息
	if len(tenHolders) > 0 {
		thNums, e := t.InsertTenHolder(c, tenHolders)
		if e != nil {
			global.LOG.Fatal("插入十大股东数据失败:", zap.Any("err", e))
			return e
		}
		global.LOG.Info("新增十大股东数据条数:", zap.Int64("nums", thNums))
	}

	//32.获取最新指标
	indicators, err := s.GetAllLatestIndicator(c, basicInfos)
	if err != nil {
		global.LOG.Fatal("初始化最新指标数据失败:", zap.Any("err", err))
		return err
	} else {
		global.LOG.Info("获取最新指标数据量：", zap.Int("nums", len(indicators)))
	}
	//printLatestIndicator(indicators)

	lic, err := t.DeleteBizData("LATEST_INDICATOR")
	if err != nil {
		global.LOG.Info("清理表【LATEST_INDICATOR】数据条数：", zap.Int64("delNums", lic))
	}

	//33.插入最新指标
	if len(indicators) > 0 {
		liNums, e := t.InsertLatestIndicator(c, indicators)
		if e != nil {
			global.LOG.Fatal("插入最新指标数据失败:", zap.Any("err", e))
			return e
		}
		global.LOG.Info("新增最新指标数据条数:", zap.Int64("nums", liNums))
	}

	//34.取得机构评级信息
	ratings, err := s.GetAllRating(c, basicInfos)
	if err != nil {
		global.LOG.Fatal("初始化机构评级信息失败！", zap.Any("err", err))
		return err
	} else {
		global.LOG.Info("获取机构评级信息数据量：", zap.Int("nums", len(ratings)))
	}

	//printRating(ratings)

	rtc, err := t.DeleteBizData("RATING")
	if err != nil {
		global.LOG.Info("清理表【RATING】数据条数：", zap.Int64("delNums", rtc))
	}

	//35. 插入机构评级信息
	if len(ratings) > 0 {
		ratingCnt, e := t.InsertRating(c, ratings)
		if e != nil {
			global.LOG.Fatal("插入机构评级信息失败！", zap.Any("err", e))
			return e
		}
		global.LOG.Info("新增机构评级信息数据条数:", zap.Int64("nums", ratingCnt))
	}

	//36.取得机构评级统计数量
	ratingCnts, err := s.GetAllRatingCount(c, basicInfos)
	if err != nil {
		global.LOG.Fatal("初始化机构评级统计数量失败！", zap.Any("err", err))
		return err
	} else {
		global.LOG.Info("获取机构评级统计数据量：", zap.Int("nums", len(ratingCnts)))
	}

	//关联数据太多不予打印了
	//printRatingCount(ratingCnts)

	rtcc, err := t.DeleteBizData("RATING_COUNT")
	if err != nil {
		global.LOG.Info("清理表【RATING_COUNT】数据条数：", zap.Int64("delNums", rtcc))
	}

	//37.插入机构评级统计数据
	if len(ratingCnts) > 0 {
		rcnts, e := t.InsertRatingCount(c, ratingCnts)
		if e != nil {
			global.LOG.Fatal("插入机构评级统计数据失败！", zap.Any("err", e))
			return e
		}
		global.LOG.Info("新增机构评级统计数据条数:", zap.Int64("nums", rcnts))
	}

	return nil
}

// InitNews 初始化资讯信息
//func InitNews(s plugins.SourceStore, t plugins.TargetStore, a plugins.InfoServiceStore) error {
func InitNews(s plugins.SourceStore, t plugins.TargetStore) error {
	c := context.Background()

	//1.取得股票基本信息
	//basicInfos, err := s.GetAllTqSkBasicInfo(c)
	//if err != nil {
	//	global.LOG.Fatal("初始化财务数据-获取股票基本信息失败！", zap.Any("err", err))
	//	return err
	//} else {
	//	global.LOG.Info("获取股票基本信息数据量：", zap.Int("nums", len(basicInfos)))
	//}

	//2.取得股票历史交易信息
	news, err := s.GetAllQNewsAnimPM(c)
	if err != nil {
		global.LOG.Fatal("初始化快讯证券信息失败:", zap.Any("err", err))
		return err
	} else {
		global.LOG.Info("获取快讯证券信息数据量：", zap.Int("nums", len(news)))
	}

	//3.取得所有快讯新闻基本信息
	//newsInfos, err := s.GetAllNews(c, news, basicInfos)
	newsInfos, err := s.GetAllNews(c, news)
	if err != nil {
		global.LOG.Fatal("获取快讯新闻基本信息数据失败:", zap.Any("err", err))
		return err
	} else {
		global.LOG.Info("获取资讯数据量：", zap.Int("nums", len(newsInfos)))
	}

	nc, err := t.DeleteBizData("NEWS")
	if err != nil {
		global.LOG.Info("清理表【NEWS】数据条数：", zap.Int64("delNums", nc))
	}

	//4.插入快讯新闻信息
	if len(newsInfos) > 0 {
		newNums, e := t.InsertNews(c, newsInfos)
		if e != nil {
			global.LOG.Fatal("插入快讯新闻基本信息数据失败:", zap.Any("err", e))
			return e
		}
		global.LOG.Info("新增快讯新闻基本信息数据条数:", zap.Int64("nums", newNums))
	}

	//5.关联公告Article表信息
	/*
		articleNums, err2 := a.InsertArticleNews(c, t)
		if err2 != nil {
			global.LOG.Fatal("插入Article资讯信息失败！", zap.Any("err", err2))
		}
		global.LOG.Info("InfoService的Article表中增加资讯数据条数:", zap.Int64("nums", articleNums))
	*/
	return nil
}

// InitSkDailyPrice 初始化股票历史日交易数据
func InitSkDailyPrice(s plugins.SourceStore, t plugins.TargetStore) error {
	c := context.Background()
	//1.取得股票基本信息
	basicInfos, err := s.GetAllTqSkBasicInfo(c)
	if err != nil {
		global.LOG.Fatal("初始化财务数据-获取股票基本信息失败:", zap.Any("err", err))
		return err
	} else {
		global.LOG.Info("获取股票基本信息数据量：", zap.Int("nums", len(basicInfos)))
	}

	sic, err := t.DeleteBizData("SK_INFO_CHANGE")
	if err != nil {
		global.LOG.Info("清理表【SK_INFO_CHANGE】数据条数：", zap.Int64("delNums", sic))
	}

	cnums, e := s.GetAllSkDailyPriceAndInsert(c, basicInfos, t)
	if e != nil {
		global.LOG.Fatal("插入证券涨跌情况数据失败:", zap.Any("err", e))
		return e
	}
	global.LOG.Info("股票历史交易信息-证券涨跌情况数据条数:", zap.Int64("nums", cnums))
	return nil
}

//InitFinancialData 初始化财务数据,包括主要指标、资产负债、利润表、现金流量表
func InitFinancialData(s plugins.SourceStore, t plugins.TargetStore) error {
	c := context.Background()

	//1.取得股票基本信息
	basicInfos, err := s.GetAllTqSkBasicInfo(c)
	if err != nil {
		global.LOG.Fatal("初始化财务数据-获取股票基本信息失败:", zap.Any("err", err))
		return err
	} else {
		global.LOG.Info("获取股票基本信息数据量：", zap.Int("nums", len(basicInfos)))
	}

	//2. 获取财务数据-主要指标：
	rows, err := s.GetAllKeyIndicatorInfo(c, basicInfos)
	if err != nil {
		global.LOG.Fatal("获取财务数据-主要指标失败:", zap.Any("err", err))
		return err
	} else {
		global.LOG.Info("获取财务主要指标数据量：", zap.Int("nums", len(rows)))
	}

	//printIndicatorInfo(rows)

	kic, err := t.DeleteBizData("KEY_INDICATOR")
	if err != nil {
		global.LOG.Info("清理表【KEY_INDICATOR】数据条数：", zap.Int64("delNums", kic))
	}

	//3.向F10 插入财务目标数据
	if len(rows) > 0 {
		kiNums, e := t.InsertKeyIndicator(c, rows)
		if e != nil {
			global.LOG.Fatal("插入财务主要指标失败:", zap.Any("err", e))
			return e
		}
		global.LOG.Info("财务数据-主要指标共新增数据条数:", zap.Int64("nums", kiNums))
	}

	//4.获取财务数据-主要指标-单季度
	indictorSqs, err := s.GetAllKeyIndicatorInfoSq(c, basicInfos)
	if err != nil {
		global.LOG.Fatal("获取财务数据-主要指标-单季度失败:", zap.Any("err", err))
		return err
	} else {
		global.LOG.Info("获取财务数据-主要指标-单季度数据量:", zap.Int("nums", len(indictorSqs)))
	}

	//printIndicatorInfoSq(indictorSqs)

	kisc, err := t.DeleteBizData("KEY_INDICATOR_SQ")
	if err != nil {
		global.LOG.Info("清理表【KEY_INDICATOR_SQ】数据条数：", zap.Int64("delNums", kisc))
	}
	//5. 插入财务数据主要指标-单季度
	if len(indictorSqs) > 0 {
		kisqNums, e := t.InsertKeyIndicatorSq(c, indictorSqs)
		if e != nil {
			global.LOG.Fatal("插入财务主要指标-单季度失败:", zap.Any("err", e))
			return e
		}
		global.LOG.Info("财务数据-主要指标-单季度共新增数据条数:", zap.Int64("nums", kisqNums))
	}

	//6.获取资产负债数据
	balanceSheets, err := s.GetAllTqFinPrgBalSheetNew(c, basicInfos)
	if err != nil {
		global.LOG.Fatal("获取财务数据-资产负债数据失败:", zap.Any("err", err))
		return err
	} else {
		global.LOG.Info("获取资产负债数据量:", zap.Int("nums", len(balanceSheets)))
	}
	//printBalanceSheetInfo(balanceSheets)

	bsc, err := t.DeleteBizData("BALANCE_SHEET")
	if err != nil {
		global.LOG.Info("清理表【BALANCE_SHEET】数据条数：", zap.Int64("delNums", bsc))
	}

	//7.向F10插入资产负债数据
	if len(balanceSheets) > 0 {
		bsNums, e := t.InsertBalanceSheet(c, balanceSheets)
		if e != nil {
			global.LOG.Fatal("插入财务资产负债数据失败:", zap.Any("err", e))
			return e
		}
		global.LOG.Info("财务数据-资产负债新增数据条数:", zap.Int64("nums", bsNums))
	}

	//8.获取企业利润信息
	incomes, err := s.GetAllIncomeStatement(c, basicInfos)
	if err != nil {
		global.LOG.Fatal("获取财务数据-企业利润数据失败:", zap.Any("err", err))
		return err
	} else {
		global.LOG.Info("获取企业利润数据量:", zap.Int("nums", len(incomes)))
	}
	//printIncomesInfo(incomes)

	isc, err := t.DeleteBizData("INCOME_STATEMENT")
	if err != nil {
		global.LOG.Info("清理表【INCOME_STATEMENT】数据条数：", zap.Int64("delNums", isc))
	}
	//9.向F10 插入企业利润数据
	if len(incomes) > 0 {
		incomeNums, e := t.InsertIncomeStatement(c, incomes)
		if e != nil {
			global.LOG.Fatal("插入企业利润数据失败:", zap.Any("err", e))
			return e
		}
		global.LOG.Info("财务数据-企业利润新增数据条数:", zap.Int64("nums", incomeNums))
	}

	//10.获取企业利润-单季度数据
	incomesqs, err := s.GetAllIncomeStatementSq(c, basicInfos)
	if err != nil {
		global.LOG.Fatal("获取财务数据-企业利润-单季度数据失败:", zap.Any("err", err))
		return err
	} else {
		global.LOG.Info("获取企业利润-单季度数据量:", zap.Int("nums", len(incomesqs)))
	}

	//printIncomesSqInfo(incomesqs)

	issc, err := t.DeleteBizData("INCOME_STATEMENT_SQ")
	if err != nil {
		global.LOG.Info("清理表【INCOME_STATEMENT_SQ】数据条数：", zap.Int64("delNums", issc))
	}

	//11.插入企业单季度利润数据
	if len(incomesqs) > 0 {
		incomeSqNums, e := t.InsertIncomeStatementSq(c, incomesqs)
		if e != nil {
			global.LOG.Fatal("插入企业利润-单季度数据失败:", zap.Any("err", e))
			return e
		}
		global.LOG.Info("财务数据-企业利润-单季度新增数据条数:", zap.Int64("nums", incomeSqNums))
	}

	//12.获取企业现金数据
	cashFlows, err := s.GetAllCashFlow(c, basicInfos)
	if err != nil {
		global.LOG.Fatal("获取财务数据-企业现金流量数据失败:", zap.Any("err", err))
		return err
	} else {
		global.LOG.Info("获取企业现金数据数据量:", zap.Int("nums", len(cashFlows)))
	}
	//printCashFlows(cashFlows)

	cfc, err := t.DeleteBizData("CASH_FLOW")
	if err != nil {
		global.LOG.Info("清理表【CASH_FLOW】数据条数：", zap.Int64("delNums", cfc))
	}
	//13.向F10 插入企业现金流数据
	if len(cashFlows) > 0 {
		cashFlowNums, e := t.InsertCashFlow(c, cashFlows)
		if e != nil {
			global.LOG.Fatal("插入企业现金流数据失败:", zap.Any("err", e))
			return e
		}
		global.LOG.Info("财务数据-企业现金流新增数据条数:", zap.Int64("nums", cashFlowNums))
	}

	//14.获取企业单季度现金数据
	cashFlowSqs, err := s.GetAllCashFlowSq(c, basicInfos)
	if err != nil {
		global.LOG.Fatal("获取财务数据-企业现金流量-单季度数据失败:", zap.Any("err", err))
		return err
	} else {
		global.LOG.Info("获取企业现金-单季度数据数据量:", zap.Int("nums", len(cashFlowSqs)))
	}

	//printCashFlowsSq(cashFlowSqs)

	cfsc, err := t.DeleteBizData("CASH_FLOW_SQ")
	if err != nil {
		global.LOG.Info("清理表【CASH_FLOW_SQ】数据条数：", zap.Int64("delNums", cfsc))
	}
	// 15.插入企业单季度现金流
	if len(cashFlowSqs) > 0 {
		cashFlowSqNums, e := t.InsertCashFlowSq(c, cashFlowSqs)
		if e != nil {
			global.LOG.Fatal("插入企业现金流-单季度数据失败:", zap.Any("err", e))
			return e
		}
		global.LOG.Info("财务数据-企业现金流-单季度新增数据条数:", zap.Int64("nums", cashFlowSqNums))
	}

	return nil
}

// InitAnnouncementData 初始化公告数据
//func InitAnnouncementData(s plugins.SourceStore, t plugins.TargetStore, a plugins.InfoServiceStore) error {
func InitAnnouncementData(s plugins.SourceStore, t plugins.TargetStore) error {
	c := context.Background()

	//1.取得股票基本信息
	basicInfos, err := s.GetAllTqSkBasicInfo(c)
	if err != nil {
		global.LOG.Fatal("初始化财务数据失败！", zap.Any("err", err))
		return err
	} else {
		global.LOG.Info("获取股票基本信息数据量：", zap.Int("nums", len(basicInfos)))
	}

	//2.取得 已发布且有效的公告信息
	announcements, err := s.GetAllAnnouncement(c, basicInfos)
	if err != nil {
		global.LOG.Fatal("获取公告数据失败！", zap.Any("err", err))
		return err
	} else {
		global.LOG.Info("获取公告数据量：", zap.Int("nums", len(announcements)))
	}

	ac, err := t.DeleteBizData("ANNOUNCEMENT")
	if err != nil {
		global.LOG.Info("清理表【ANNOUNCEMENT】数据条数：", zap.Int64("delNums", ac))
	}

	//3.新增公告数据
	if len(announcements) > 0 {
		announceNums, err1 := t.InsertAnnouncement(c, announcements)
		if err1 != nil {
			global.LOG.Fatal("插入公告数据失败！", zap.Any("err", err1))
			return err1
		}
		global.LOG.Info("公告新增数据条数:", zap.Int64("nums", announceNums))
	}

	//4.关联公告Article表信息
	/*
		articleNums, err2 := a.InsertArticleAnnouncements(c, t)
		if err2 != nil {
			global.LOG.Fatal("插入Article公告信息失败！", zap.Any("err", err2))
		}
		global.LOG.Info("InfoService的Article表中增加公告数据条数:", zap.Int64("nums", articleNums))
	*/
	return nil
}

// LoadData 补充业务数据操作
func LoadData(s plugins.SourceStore, t plugins.TargetStore, bizType string, biz string, beginDate string, endDate string) {
	switch bizType {
	case Oper_Init_News: //快讯
		err := loadNewsData(s, t, beginDate, endDate)
		if err != nil {
			global.LOG.Fatal("补充证券快讯数据失败！", zap.Any("err", err))
		}
	case Oper_Init_Announcement: //公告
		err := loadAnnouncementData(s, t, beginDate, endDate)
		if err != nil {
			global.LOG.Fatal("补充公告数据失败！", zap.Any("err", err))
		}
	case Oper_Init_Info: // 资料
		err := loadInfoData(s, t, biz, beginDate, endDate)
		if err != nil {
			global.LOG.Fatal("补充资料数据失败！", zap.Any("err", err))
		}
	case Oper_Init_Finance: // 财务
		err := loadFinData(s, t, biz, beginDate, endDate)
		if err != nil {
			global.LOG.Fatal("补充资料数据失败！", zap.Any("err", err))
		}

	default:
		global.LOG.Info("......没有进行任何操作......")
	}
}

func loadFinData(s plugins.SourceStore, t plugins.TargetStore, biz string, beginDate string, endDate string) error {
	c := context.Background()

	switch biz {
	case ZYZB:
		// 主要指标
		global.LOG.Info("补充主要指标数据开始...")
		v, err := s.GetAppendedBizData(c, "TQ_FIN_PRGFINMAININDEX", beginDate, endDate)
		if err != nil {
			global.LOG.Fatal("查询相应时间间隔的主要指标数据失败:", zap.Any("err", err))
			return err
		}

		err = t.FixBizData(c, v)
		if err != nil {
			global.LOG.Fatal("补充主要指标数据失败:", zap.Any("err", err))
			return err
		}
		global.LOG.Info("补充主要指标数据结束...")

	case ZCFZ:
		// 资产负债
		global.LOG.Info("补充资产负债数据开始...")

		v, err := s.GetAppendedBizData(c, "TQ_FIN_PRGBALSHEETNEW", beginDate, endDate)
		if err != nil {
			global.LOG.Fatal("查询相应时间间隔的资产负债数据失败:", zap.Any("err", err))
			return err
		}

		err = t.FixBizData(c, v)
		if err != nil {
			global.LOG.Fatal("补充资产负债数据失败:", zap.Any("err", err))
			return err
		}
		global.LOG.Info("补充资产负债数据结束...")

	case LR:
		// 一般企业利润
		global.LOG.Info("补充企业利润数据开始...")

		v, err := s.GetAppendedBizData(c, "TQ_FIN_PRGINCSTATEMENTNEW", beginDate, endDate)
		if err != nil {
			global.LOG.Fatal("查询相应时间间隔的企业利润数据失败:", zap.Any("err", err))
			return err
		}

		err = t.FixBizData(c, v)
		if err != nil {
			global.LOG.Fatal("补充企业利润数据失败:", zap.Any("err", err))
			return err
		}
		global.LOG.Info("补充企业利润数据结束...")

	case XJL:
		//现金流量
		global.LOG.Info("补充现金流数据开始...")

		v, err := s.GetAppendedBizData(c, "TQ_FIN_PRGCFSTATEMENTNEW", beginDate, endDate)
		if err != nil {
			global.LOG.Fatal("查询相应时间间隔的现金流数据失败:", zap.Any("err", err))
			return err
		}

		err = t.FixBizData(c, v)
		if err != nil {
			global.LOG.Fatal("补充现金流数据失败:", zap.Any("err", err))
			return err
		}
		global.LOG.Info("补充现金流数据结束...")

	case ZYZBDJD:
		// 主要指标-单季度
		global.LOG.Info("补充主要指标单季度数据开始...")

		v, err := s.GetAppendedBizData(c, "TQ_FIN_PROQINDIC", beginDate, endDate)
		if err != nil {
			global.LOG.Fatal("查询相应时间间隔的主要指标-单季度数据失败:", zap.Any("err", err))
			return err
		}

		err = t.FixBizData(c, v)
		if err != nil {
			global.LOG.Fatal("补充主要指标-单季度数据失败:", zap.Any("err", err))
			return err
		}
		global.LOG.Info("补充主要指标单季度数据结束...")

	case LRDJD:
		// 企业利润单季度
		global.LOG.Info("补充企业利润单季度数据开始...")

		v, err := s.GetAppendedBizData(c, "TQ_FIN_PRGPASQSUBJECTS", beginDate, endDate)
		if err != nil {
			global.LOG.Fatal("查询相应时间间隔的企业利润单季度数据失败:", zap.Any("err", err))
			return err
		}

		err = t.FixBizData(c, v)
		if err != nil {
			global.LOG.Fatal("补充企业利润单季度数据失败:", zap.Any("err", err))
			return err
		}
		global.LOG.Info("补充企业利润单季度数据结束...")

	case XJLDJD:
		// 现金流单季度
		global.LOG.Info("补充现金流单季度数据开始...")

		v, err := s.GetAppendedBizData(c, "TQ_FIN_PRGCFSQSUBJECTS", beginDate, endDate)
		if err != nil {
			global.LOG.Fatal("查询相应时间间隔的现金流单季度数据失败:", zap.Any("err", err))
			return err
		}

		err = t.FixBizData(c, v)
		if err != nil {
			global.LOG.Fatal("补充现金流单季度数据失败:", zap.Any("err", err))
			return err
		}
		global.LOG.Info("补充现金流单季度数据结束...")

	default:
		global.LOG.Info("......没有输入具体的业务信息或业务信息输入错误......")
	}

	return nil
}

func loadInfoData(s plugins.SourceStore, t plugins.TargetStore, biz string, beginDate string, endDate string) error {
	c := context.Background()

	switch biz {
	case ZXZB:
		global.LOG.Info("补充最新指标数据开始...")
		// 最新指标
		v, err := s.GetAppendedBizData(c, "TQ_SK_FUNDAMENTALS", beginDate, endDate)
		if err != nil {
			global.LOG.Fatal("查询相应时间间隔的最新指标信息数据失败:", zap.Any("err", err))
			return err
		}

		err = t.FixBizData(c, v)
		if err != nil {
			global.LOG.Fatal("补充最新指标数据失败:", zap.Any("err", err))
			return err
		}
		global.LOG.Info("补充最新指标数据结束...")
	case DSTX:
		//大事提醒
		global.LOG.Info("补充大事提醒数据开始...")
		v, err := s.GetAppendedBizData(c, "TQ_SK_IMPORTEVENT", beginDate, endDate)
		if err != nil {
			global.LOG.Fatal("查询相应时间间隔的大事提醒数据失败:", zap.Any("err", err))
			return err
		}

		err = t.FixBizData(c, v)
		if err != nil {
			global.LOG.Fatal("补充大事提醒数据失败:", zap.Any("err", err))
			return err
		}
		global.LOG.Info("补充大事提醒数据结束...")
	case FHPS:
		//分红派送
		global.LOG.Info("补充分红派送数据开始...")
		v, err := s.GetAppendedBizData(c, "TQ_SK_BONUS", beginDate, endDate)
		if err != nil {
			global.LOG.Fatal("查询相应时间间隔的分红派送数据失败:", zap.Any("err", err))
			return err
		}

		err = t.FixBizData(c, v)
		if err != nil {
			global.LOG.Fatal("补充分红派送数据失败:", zap.Any("err", err))
			return err
		}
		global.LOG.Info("补充分红派送数据结束...")
	case RZRQ:
		//融资融劵
		global.LOG.Info("补充融资融券数据开始...")
		v, err := s.GetAppendedBizData(c, "TQ_SK_FINMRGNINFO", beginDate, endDate)
		if err != nil {
			global.LOG.Fatal("查询相应时间间隔的融资融券数据失败:", zap.Any("err", err))
			return err
		}

		err = t.FixBizData(c, v)
		if err != nil {
			global.LOG.Fatal("补充融资融券数据失败:", zap.Any("err", err))
			return err
		}
		global.LOG.Info("补充融资融券数据结束...")
	case YLYC:
		// 盈利预测
		global.LOG.Info("补充盈利预测数据开始...")
		v, err := s.GetAppendedBizData(c, "TQ_EXPT_SKSTATN", beginDate, endDate)
		if err != nil {
			global.LOG.Fatal("查询相应时间间隔的盈利预测数据失败:", zap.Any("err", err))
			return err
		}

		err = t.FixBizData(c, v)
		if err != nil {
			global.LOG.Fatal("补充盈利预测数据失败:", zap.Any("err", err))
			return err
		}
		global.LOG.Info("补充盈利预测数据结束...")
	case JGPJXX:
		// 机构评级信息
		global.LOG.Info("补充机构评级信息数据开始...")
		v, err := s.GetAppendedBizData(c, "TQ_EXPT_SKINVRATING", beginDate, endDate)
		if err != nil {
			global.LOG.Fatal("查询相应时间间隔的机构评级信息数据失败:", zap.Any("err", err))
			return err
		}

		err = t.FixBizData(c, v)
		if err != nil {
			global.LOG.Fatal("补充机构评级信息数据失败:", zap.Any("err", err))
			return err
		}
		global.LOG.Info("补充机构评级信息数据结束...")
	case JGPJTJ:
		//机构评级统计
		global.LOG.Info("补充机构评级统计数据开始...")
		v, err := s.GetAppendedBizData(c, "TQ_EXPT_SKINVRATING2", beginDate, endDate)
		if err != nil {
			global.LOG.Fatal("查询相应时间间隔的机构评级信息数据失败:", zap.Any("err", err))
			return err
		}

		err = t.FixBizData(c, v)
		if err != nil {
			global.LOG.Fatal("补充机构评级信息数据失败:", zap.Any("err", err))
			return err
		}
		global.LOG.Info("补充机构评级统计数据结束...")

	case GSJK:
		// 公司解基本情况
		global.LOG.Info("补充公司简况数据开始...")

		v, err := s.GetAppendedBizData(c, "TQ_COMP_INFO", beginDate, endDate)
		if err != nil {
			global.LOG.Fatal("查询相应时间间隔的公司基本情况数据失败:", zap.Any("err", err))
			return err
		}

		err = t.FixBizData(c, v)
		if err != nil {
			global.LOG.Fatal("补充公司基本情况数据失败:", zap.Any("err", err))
			return err
		}
		global.LOG.Info("补充公司简况数据结束...")
	case GSZYYW:
		// 公司主要业务
		global.LOG.Info("补充公司主要业务数据开始...")
		v, err := s.GetAppendedBizData(c, "TQ_SK_BUSIINFO", beginDate, endDate)
		if err != nil {
			global.LOG.Fatal("查询相应时间间隔的公司主要业务数据失败:", zap.Any("err", err))
			return err
		}

		err = t.FixBizData(c, v)
		if err != nil {
			global.LOG.Fatal("补充公司主要业务数据失败:", zap.Any("err", err))
			return err
		}
		global.LOG.Info("补充公司主要业务数据结束...")
	case GSGG:
		//  公司高管
		global.LOG.Info("补充公司高管数据开始...")
		v, err := s.GetAppendedBizData(c, "TQ_COMP_MANAGER", beginDate, endDate)
		if err != nil {
			global.LOG.Fatal("查询相应时间间隔的公司高管数据失败:", zap.Any("err", err))
			return err
		}

		err = t.FixBizData(c, v)
		if err != nil {
			global.LOG.Fatal("补充公司高管数据失败:", zap.Any("err", err))
			return err
		}
		global.LOG.Info("补充公司高管数据结束...")

	case GBJG:
		//股本结构信息
		global.LOG.Info("补充股本结构信息数据开始...")
		v, err := s.GetAppendedBizData(c, "TQ_SK_SHARESTRUCHG", beginDate, endDate)
		if err != nil {
			global.LOG.Fatal("查询相应时间间隔的股本结构数据失败:", zap.Any("err", err))
			return err
		}

		err = t.FixBizData(c, v)
		if err != nil {
			global.LOG.Fatal("补充股本结构数据失败:", zap.Any("err", err))
			return err
		}
		global.LOG.Info("补充股本结构信息数据结束...")
	case GBBD:
		//股本变动数据
		global.LOG.Info("补充股本变动数据开始...")
		v, err := s.GetAppendedBizData(c, "TQ_SK_SHARESTRUCHG2", beginDate, endDate)
		if err != nil {
			global.LOG.Fatal("查询相应时间间隔的股本变动数据失败:", zap.Any("err", err))
			return err
		}

		err = t.FixBizData(c, v)
		if err != nil {
			global.LOG.Fatal("补充股本变动数据失败:", zap.Any("err", err))
			return err
		}
		global.LOG.Info("补充股本变动数据结束...")
	case SDLTGD:
		// 十大流通股股东
		global.LOG.Info("补充十大流通股东数据开始...")
		v, err := s.GetAppendedBizData(c, "TQ_SK_OTSHOLDER", beginDate, endDate)
		if err != nil {
			global.LOG.Fatal("查询相应时间间隔的十大流通股股东数据失败:", zap.Any("err", err))
			return err
		}

		err = t.FixBizData(c, v)
		if err != nil {
			global.LOG.Fatal("补充十大流通股股东数据失败:", zap.Any("err", err))
			return err
		}
		global.LOG.Info("补充十大流通股东数据结束...")
	case SDGD:
		// 十大股东
		global.LOG.Info("补充十大股东数据开始...")
		v, err := s.GetAppendedBizData(c, "TQ_SK_SHAREHOLDER", beginDate, endDate)
		if err != nil {
			global.LOG.Fatal("查询相应时间间隔的十大股东数据失败:", zap.Any("err", err))
			return err
		}

		err = t.FixBizData(c, v)
		if err != nil {
			global.LOG.Fatal("补充十大股东数据失败:", zap.Any("err", err))
			return err
		}
		global.LOG.Info("补充十大股东数据结束...")
	case FHRZ:
		// 分红融资
		global.LOG.Info("补充分红融资数据开始...")
		v, err := s.GetAppendedBizData(c, "TQ_SK_BONUS2", beginDate, endDate)
		if err != nil {
			global.LOG.Fatal("查询相应时间间隔的分红派送数据失败:", zap.Any("err", err))
			return err
		}

		err = t.FixBizData(c, v)
		if err != nil {
			global.LOG.Fatal("补充分红派送数据失败:", zap.Any("err", err))
			return err
		}
		global.LOG.Info("补充分红融资数据结束...")
	case LHB:
		//龙虎榜
		global.LOG.Info("补充龙虎榜数据开始...")
		v, err := s.GetAppendedBizData(c, "TQ_QT_BIZUNITTRDINFO", beginDate, endDate)
		if err != nil {
			global.LOG.Fatal("查询相应时间间隔的分红派送数据失败:", zap.Any("err", err))
			return err
		}

		err = t.FixBizData(c, v)
		if err != nil {
			global.LOG.Fatal("补充分红派送数据失败:", zap.Any("err", err))
			return err
		}
		global.LOG.Info("补充龙虎榜数据结束...")
	case DZJY:
		//  大宗交易
		global.LOG.Info("补充大宗交易数据开始...")
		v, err := s.GetAppendedBizData(c, "TQ_QT_BLOCKTRADE", beginDate, endDate)
		if err != nil {
			global.LOG.Fatal("查询相应时间间隔的大宗交易数据失败:", zap.Any("err", err))
			return err
		}

		err = t.FixBizData(c, v)
		if err != nil {
			global.LOG.Fatal("补充大宗交易数据失败:", zap.Any("err", err))
			return err
		}
		global.LOG.Info("补充大宗交易数据结束...")
	case GDBD:
		// 股东变动数据
		global.LOG.Info("补充股东变动数据开始...")
		v, err := s.GetAppendedBizData(c, "TQ_SK_SHAREHOLDERNUM", beginDate, endDate)
		if err != nil {
			global.LOG.Fatal("查询相应时间间隔的股东变动数据失败:", zap.Any("err", err))
			return err
		}

		err = t.FixBizData(c, v)
		if err != nil {
			global.LOG.Fatal("补充股东变动数据失败:", zap.Any("err", err))
			return err
		}
		global.LOG.Info("补充股东变动数据结束...")
	default:
		global.LOG.Info("......没有输入具体的业务信息或业务信息输入错误......")
	}

	return nil

}

// loadNewsData 补充资讯数据
func loadNewsData(s plugins.SourceStore, t plugins.TargetStore, beginDate string, endDate string) error {
	c := context.Background()

	//1.取得相应时间段的股票历史交易信息
	global.LOG.Info("补充资讯数据开始...")
	sourceKeys, err := s.GetAllQNewsAnimPM4Fix(c, beginDate, endDate)
	if err != nil {
		global.LOG.Fatal("查询相应时间间隔的快讯证券数据失败:", zap.Any("err", err))
		return err
	} else {
		global.LOG.Info("获取相应时间间隔的快讯证券信息数据量：", zap.Int("nums", len(sourceKeys)))
	}

	//2.补充快讯新闻信息
	err = s.FixNews(c, sourceKeys, t)
	if err != nil {
		global.LOG.Fatal("补充快讯证券数据失败:", zap.Any("err", err))
	}
	global.LOG.Info("补充资讯数据结束...")
	return nil
}

// loadAnnouncementData 补充公告数据
func loadAnnouncementData(s plugins.SourceStore, t plugins.TargetStore, beginDate string, endDate string) error {
	c := context.Background()

	// 1.取得指定时间间隔的公告信息
	global.LOG.Info("补充公告数据开始...")
	announcements, err := s.GetAllAnnouncement4Fix(c, beginDate, endDate)
	if err != nil {
		global.LOG.Fatal("查询相应时间间隔的公告数据失败:", zap.Any("err", err))
		return err
	} else {
		global.LOG.Info("获取相应时间间隔的公告数据量：", zap.Int("nums", len(announcements)))
	}

	//2.补充公告数据
	err = t.FixAnnouncements(c, announcements)
	if err != nil {
		global.LOG.Fatal("补充公告数据失败:", zap.Any("err", err))
	}
	global.LOG.Info("补充公告数据结束...")
	return nil
}
